Rename the actual_channel_name identifier to curr_channel_name. This
was introduced in commit 17a82e8.

Whitespace change exclusively, no change in behaviour. Reduce the level
of indentation of continuation lines in common SCPI code's header and
source files. See a whitespace ignoring diff for review.

A TAB is sufficient to represent a level of indentation. More than this,
up to four of them, or additional SPACE after TAB is excessive. Drop it.

Rename retry count and delay parameters which exclusively were used in
the "*OPC?" result getter. Prefer while-not-done over counted for loop.
Only return success when SCPI communication was successful and the
value is true-ish (communication was not checked explicitly before,
instead relied on internal implementation details of the bool getter).

Rephrase the scpi_dev_inst_new() routine for code style and robustness.
Don't hide assignments in declaration blocks. Unobfuscate string compare
and reduce indentation in the prefix match loop. Don't mix function call
and result check and flow control in a single statement. Don't access
uninitialized data in error paths (resource release call).

Avoid tight read loops when a SCPI device is busy creating the very
response that the host is trying to receive. Add a new 'read_pause_us'
member next to the existing 'read_timeout_us'. Default to zero for
maximum  backwards compatibility.

Pause between read calls when an attempt sees zero receive data. Adjust
the internal scpi_get_data() and the public sr_scpi_get_block() routines,
which other SCPI routines are built upon.

Adjust the internal scpi_get_data() routine which collects a SCPI
response message. Add in/out decorations to Doxygen comments. Group
instructions that execute a logical sequence which belongs together
(eliminate clutter). Use size types for string buffer lengths.

Move code which keeps growing a string buffer before accumulating more
receive data out of the scpi_read_data() routine and into a separate
helper. The block reader wants to share this logic.

SCPI transports construct connection ID strings for display purposes.
The SCPI over TCP implementation did present the essential details
(IP address, TCP port), but yielded an output format which does not
work as an SR_CONF_CONN value. The colon separator even breaks CLI
option parsing.

Separate IP address and TCP port by means of a slash. Generate a
connection ID text which matches all other transports, and also works
for the creation of new device instances.

The SCPI protocol usually communicates requests (commands, queries) and
responses in ASCII format. But also supports the concept of data blocks
which carry raw byte sequences. Checking for CR or LF characters in
response text does not combine well with transmission of raw bytes.

Introduce a "block ends" method for SCPI transports. Common code is
aware when a data block is received, and where it ends. That's when
transports can re-consider their end-of-message condition for the
remaining reception of that very response. The transport method sees
all previously accumulated receive data that follows the data block.

Implement that "block ends" method in the serial transport, which
motivated the introduction of the method. Void falsely detected "is
complete" conditions that originate from seeing CR or LF in byte data.

Other transports derive their respective end-of-message condition from
other information which is not affected (EOI signals, VISA status bits,
TCP with length specs in headers before data, USB transfer flags, etc).

Fix typos in comments, and update comments which went stale in earlier
commits. Mention that "indefinite length block" is not supported in the
routine's Doxygen comment for callers' awareness.

Address tiny style nits while we are here: Asterisk placement in pointer
declarations. Braces around complex multi-line statements. Drop empty
lines in groups of statements that belong together. Un-clutter their
comments, discuss the whole group in one text.

Rephrase the sr_scpi_get_block() routine to increase readability and
robustness. Address data type issues (signedness). Rename variables to
better reflect their purpose. Concentrate more comments before larger
instruction sequences. Mention instructions' purpose first before more
detailled discussion, to speedup reader's navigation in the complex
logic. Reword the discussion of definite and indefinite length blocks.
Add more diagnostics. Although the text diff is huge, the spirit of
the previous implementation is kept.

Rephrase loops when the motivation for their phrasing was uncertain:
Replace "if (cond) do { ... } while (cond)" with just "while (cond)".
Which reduces nesting and indentation. Use "while" instead of "do while"
when it's obvious that the body does initially execute. It's believed
that behaviour remains identical.

This commit also changes behaviour: Re-arm timeouts more often after
receive data was seen. Which helps slow transports, yet does not harm
fast transports which already accumulated the input data for the next
stage of processing. Check for zero length in more locations (accept
phrases like "sigrokproject#10" as well).

There is excessive diagnostics. Needs more adjustment (wording, levels).

The previous sr_scpi_get_block() implementation immediately returned
after grabbing the data block. Which could have worked by coincidence
when fast transports queue large chunks of receive data early, or could
have gone unnoticed because there are few callers (hameg, lecroy only).

Keep reading after the data block until the underlying transport finds
the response message's end. Skipping this step could result in seeing
"empty responses" for the next request, and synchronization loss for
the remaining session when responses no longer correspond to callers'
requests. Probability to reproduce depends on the type and speed of
the involved transport, and how the device firmware chunks responses.

SCPI responses are expected to either come in pure text format (ASCII),
_or_ raw bytes (data blocks). Tektronix TDS2000 was observed to respond
with the unusual combination of a data block that is preceeded(!) by
variable length(!) text fields which are separated by semicolon. This
is the consequence of the "WAVF?" request being an aggregate, sending
several properties including the "CURVE" response in the same message.

Introduce a rather specific "get (an optional) text then data block"
reader routine, which uses caller provided logic to identify the
position of the data block in the response. Tested with TDS 220.

The implementation re-uses the previously existing "get block" routine
and extends it to optionally get a leading text. While lots of more
diagnostics are added. Two very thin public wrapper routines provide
the "get block" and "get (text and) block" semantics.

There is excessive diagnostics. Levels and wording needs adjustment.